package gambit.jogador;

import gambit.core.Tabuleiro;

public class Utilidade {

	public static final int NUMERO_HEURISTICAS = 13;

	// posicionamento nas laterais
	private static int hPosicional = 500;

	// avanï¿œo das peï¿œas
	private static int hAvancoAliado = 500;

	// evitar avanï¿œo das peï¿œas do oponente
	private static int hAvancoInimigo = 800;

	// contabiliza nï¿œmero de casas adjacentes livres
	private static int hMobilidade = 200;

	// contabiliza damas
	private static int hDamas = 1000;

	// contabiliza peï¿œas com 4 adjacï¿œncias livres
	private static int hVala = 100;

	// protege a linha de conversï¿œo
	private static int hRetaguarda = 300;

	// favorece o posicionamento de 3 peï¿œas em diagonal
	private static int hDyke = 500;

	// contabiliza chances de ataque
	private static int hThret = 200;

	// evita multiplos aprisionamentos do oponentes
	private static int hMultiCadeia = 1000;

	// dama killer
	private static int hDamaKiller = 1000;

	// número de peças
	private static int hNumeroPecas = 1000;

	// evita perda de peças
	private static int hDefensiva = 1500;

	public static int getCusto(Tabuleiro tabuleiro) {

		int[] vetorCasas = tabuleiro.getCasas();

		return hPosicional * heuristicaPosicional(vetorCasas) + hAvancoAliado
				* heuristicaAvancoAliado(vetorCasas) + hAvancoInimigo
				* heuristicaAvancoInimigo(vetorCasas) + hMobilidade
				* heuristicaMobilidade(vetorCasas) + hDamas
				* heuristicaDamas(vetorCasas) + hVala
				* heuristicaVala(vetorCasas) + hRetaguarda
				* heuristicaRetaguarda(vetorCasas) + hDyke
				* heuristicaDyke(vetorCasas) + hThret
				* heuristicaThret(vetorCasas) + hMultiCadeia
				* heuristicaAntiCadeia(vetorCasas) + hDamaKiller
				* heuristicaDamaKiller(vetorCasas) + hNumeroPecas
				* heuristicaNumeroPecas(vetorCasas) + hDefensiva
				* heuristicaDefensiva(vetorCasas);
	}

	private static int heuristicaPosicional(int[] vetorCasas) {

		int valor = 0;

		for (int i = 0; i < 32; i++) {

			if ((i >= 0 && i <= 3) || i % 8 == 0 || i % 8 == 7
					|| (i <= 31 && i >= 28)) {
				valor = valor + 3 * vetorCasas[i];
			}

			else if ((i >= 4 && i <= 6) || i % 8 == 3 || i % 8 == 4
					|| (i <= 27 && i >= 25)) {
				valor = valor + 2 * vetorCasas[i];
			}

			else if ((i == 21) || i % 8 == 1 || i % 8 == 6 || (i == 10)) {
				valor = valor + 2 * vetorCasas[i];
			}

			else {
				valor = valor + vetorCasas[i];
			}

		}

		return valor;
	}

	// private int trianguloDefensivo() {
	// return 0;
	// }

	// calcula heurï¿œstica com base na possibilidade de movimentaï¿œï¿œo futura
	// das
	// peï¿œas aliadas
	private static int heuristicaMobilidade(int[] vetorCasas) {

		int soma = 0;
		for (int i = 31; i >= 4; i--) {
			if (((i / 4) % 2 == 0 && vetorCasas[i] == 0 && (vetorCasas[i - 5] > 0 || vetorCasas[i - 4] > 0)) // fileiras
					// pares
					|| ((i / 4) % 2 == 1 && vetorCasas[i] == 0 && (vetorCasas[i - 4] > 0 || vetorCasas[i - 3] > 0)) // fileiras
					// ï¿œmpares
					|| ((i / 4) % 2 == 0 && vetorCasas[i] == 0 && (vetorCasas[i + 4] == 2 || vetorCasas[i + 3] == 2)) // mov
					// damas
					// para
					// trï¿œs
					|| ((i / 4) % 2 == 1 && i / 4 != 7 && vetorCasas[i] == 0 && (vetorCasas[i + 5] == 2 || vetorCasas[i + 4] == 2)) // mov
			// damas
			// para
			// trï¿œs
			) {
				soma++;
			}

		}

		return soma;
	}

	private static int heuristicaNumeroPecas(int[] vetorCasas) {

		int somaP = 0;
		//int somaB = 0;

		for (int i = 0; i < 32; i++) {
			if (vetorCasas[i] > 0) {
				somaP++;
			}

//			else if (vetorCasas[i] < 0) {
//				somaB--;
//			}
		}

		return somaP;
	}

	private static int heuristicaAvancoAliado(int[] vetorCasas) {

		int soma = 0;
		for (int i = 27; i >= 20; i--) {
			if (vetorCasas[i] == 1) {
				soma++;
			}
		}

		return soma;
	}

	private static int heuristicaAvancoInimigo(int[] vetorCasas) {

		int soma = 0;
		for (int i = 4; i <= 11; i++) {
			if (vetorCasas[i] == -1) {
				soma--;
			}
		}

		return soma;
	}

	private static int heuristicaDamas(int[] vetorCasas) {
		int soma = 0;

		for (int i = 0; i <= 31; i++) {
			if (vetorCasas[i] == 2) {
				soma++;
			}
		}

		// if(soma >= 2 && getHPosicional() >= 2){
		// setHPosicional(hPosicional - 1);
		// setHMobilidade(hMobilidade + 1);
		// setHThret(hThret + 1);
		// }
		// if(soma < 2 && getHPosicional() < 2){
		// setHMobilidade(hMobilidade + 1);
		// setHThret(hThret - 1);
		// }

		return soma;
	}

	// terminar - considera vantagem uma peï¿œa com vizinhanï¿œa vazia
	private static int heuristicaVala(int[] vetorCasas) {
		int soma = 0;

		for (int i = 0; i < 32; i++) {
			if (vetorCasas[i] >= 0) {
				// verifica se estï¿œ cercado por vala:
				int y = getY(i);
				int x = getX(i);

				int dsd = getPoint(x + 1, y + 1); // diagonal superior direita
				int dse = getPoint(x - 1, y + 1); // diagonal superior esquerda
				int did = getPoint(x + 1, y - 1); // diagonal inferior direita
				int die = getPoint(x - 1, y - 1); // diagonal inferior esquerda

				if (dsd > 0 && dse > 0 && did > 0 && die > 0) {
					if (vetorCasas[dsd] == 0 && vetorCasas[dse] == 0
							&& vetorCasas[did] == 0 && vetorCasas[die] == 0) {
						soma++;
					}
				}
			}
		}

		return soma;
	}

	// considera vantajoso a linha de retaguarda preenchida por aliados, e
	// desvantajoso a retaguarda inimiga preenchida
	private static int heuristicaRetaguarda(int[] vetorCasas) {
		int soma = 0;

		for (int i = 0; i < 4; i++) {
			if (vetorCasas[i] > 0) {
				soma++;
			}
		}

		// for (int i = 28; i < 32; i++) {
		// if (vetorCasas[i] < 0) {
		// soma--;
		// }
		// }

		return soma;
	}

	// heuristica Dyke: considera vantagem trï¿œs ou mais peï¿œas alinhadas na
	// mesma
	// diagonal
	private static int heuristicaDyke(int[] vetorCasas) {
		int soma = 0;

		// int[][] tabuleiro = uniToBi(vetorCasas);
		int dd1, dd2, de1, de2, p;

		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {

				if ((i + j) % 2 == 0) {
					p = (i) * 4 + (j) / 2;
					dd1 = (i + 1) * 4 + (j + 1) / 2;
					dd2 = (i + 2) * 4 + (j + 2) / 2;
					de1 = (i + 1) * 4 + (j - 1) / 2;
					de2 = (i + 2) * 4 + (j - 2) / 2;

					if ((dd1 >= 0 && dd1 < 32)
							&& (dd2 >= 0 && dd2 < 32)
							&& (de1 >= 0 && de1 < 32)
							&& (de2 >= 0 && de2 < 32)
							&& ((vetorCasas[p] > 0 && vetorCasas[dd1] > 0 && vetorCasas[dd2] > 0) || (vetorCasas[p] > 0
									&& vetorCasas[de1] > 0 && vetorCasas[de2] > 0))) {

						soma++;
					}
				}
			}
		}

		return soma;
	}

	private static int heuristicaThret(int[] V) {

		int valor = 0;
		int linha;
		for (int i = 4; i < 32; i++) {
			if (V[i] >= 1) {
				linha = (int) Math.ceil(i / 4);
				if (linha % 2 == 1) {

					if ((i > 3 && i < 24) ) {		//&& V[i - 4] > 0

						if (i % 4 != 0 && i % 4 != 3) {

							if (V[i - 3] > 0
									&& ((V[i + 4] < 0 && V[i + 7] == 0) ))
								valor++;
							else if(V[i - 4] > 0 && (V[i + 5] < 0 && V[i + 9] == 0))
								valor++; 
						} else if (i % 4 == 0) {
							if (V[i - 4] > 0 && (V[i + 5] < 0 && V[i + 9] == 0))
								valor++;
						} else if (i % 4 == 3) {
							if ((V[i + 4] < 0 && V[i + 7] == 0))
								valor++;
						}
					}
					if (i > 8 && i < 24 && V[i] == 2) {

						if (i % 4 != 0 && i % 4 != 3 ) {

							if ( V[i + 4] > 0 && ((V[i - 3] < 0 && V[i -7] == 0) ))
								valor++;
							else if( V[i + 5] > 0 &&  V[i - 4] < 0 && V[i - 9] == 0)
									valor++;
									
						}

						else if (i % 4 == 0 && V[i + 4] > 0 && (V[i - 3] < 0 && V[i -7] == 0))
								valor++;
						else if (i % 4 == 3 && (V[i - 4] < 0 && V[i - 9] == 0))
								valor++;
						
					}
				}

				if (linha % 2 == 0){

					if ((i > 3 && i < 24) ) {		

						if (i % 4 != 0 && i % 4 != 3) {

							if (V[i - 4] > 0
									&& ((V[i + 3] < 0 && V[i + 7] == 0) ))
								valor++;
							else if(V[i - 5] > 0 && (V[i + 4] < 0 && V[i + 9] == 0))
								valor++; 
						} else if (i % 4 == 0) {
							if ( (V[i + 4] < 0 && V[i + 8] == 0))
								valor++;
						} else if (i % 4 == 3) {
							if (V[i -4] > 0 && (V[i + 3] < 0 && V[i + 7] == 0))
								valor++;
						}
					}
					if (i > 8 && i < 24 && V[i] == 2) {

						if (i % 4 != 0 && i % 4 != 3 ) {

							if ( V[i + 3] > 0 && ((V[i - 4] < 0 && V[i -7] == 0) ))
								valor++;
							else if( V[i + 4] > 0 &&  V[i - 5] < 0 && V[i - 9] == 0)
									valor++;
									
						}

						else if (i % 4 == 3 && V[i + 4] > 0 && (V[i - 5] < 0 && V[i -9] == 0))
								valor++;
						else if (i % 4 == 0 && (V[i - 4] < 0 && V[i - 7] == 0))
								valor++;
						
					}
				}

			}

		}
		return valor;
	}


	private static int heuristicaAntiCadeia(int[] V) {

		int valor = 0;
		int linha;
		for (int i = 0; i < 32; i++) {
			if (V[i] > 0) {
				linha = (int) Math.ceil(i / 4);
				if (linha % 2 == 1) {

					if ((i > 11) && i < 24 && (i % 4 != 3)) {

						if (V[i + 4] <= -1 && V[i - 3] == 0) {
							if (V[i - 8] > 0 && V[i - 12] == 0)
								valor--;
							else if (V[i - 7] > 0 && V[i - 10] == 0
									&& i % 4 != 2)
								valor--;
							else if (i % 4 != 2 && V[i + 4] == -2
									&& V[i + 1] > 0 && V[i + 6] == 0)
								valor--;

						}
					}
					if ((i > 12) && i < 24 && (i % 4 != 3)) {

						if (V[i + 5] <= -1 && V[i - 4] == 0) {
							if (V[i - 8] > 0 && V[i - 11] == 0)
								valor--;
							else if (V[i - 9] > 0 && V[i - 13] == 0
									&& i % 4 != 2)
								valor--;
							else if (i % 4 != 0 && V[i + 5] == -2
									&& V[i - 1] > 0 && V[i + 3] == 0)
								valor--;
						}
					}
					if ((i == 12 || i == 20) && V[i + 5] <= -1 && V[i - 4] == 0
							&& V[i - 8] > 0 && V[i - 11] == 0)
						valor--;
				}

				if (linha % 2 == 0) {

					if ((i > 13) && i < 28 && (i % 4 != 0)) {

						if (V[i + 4] <= -1 && V[i - 5] == 0) {
							if (V[i - 8] > 0 && V[i - 12] == 0)
								valor--;
							else if (V[i - 9] > 0 && V[i - 14] == 0
									&& i % 4 != 1)
								valor--;
							else if (i % 4 != 1 && V[i + 4] == -2
									&& V[i - 1] > 0 && V[i + 2] == 0)
								valor--;

						}
					}
					if ((i > 12) && i < 28 && (i % 4 != 0)) {

						if (V[i + 3] <= -1 && V[i - 4] == 0) {
							if (V[i - 8] > 0 && V[i - 13] == 0)
								valor--;
							else if (V[i - 7] > 0 && V[i - 11] == 0
									&& i % 4 != 3)
								valor--;
							else if (i % 4 != 3 && V[i + 3] == -2
									&& V[i + 1] > 0 && V[i + 5] == 0)
								valor--;
						}
					}
					if ((i == 19 || i == 27) && V[i + 3] <= -1 && V[i - 4] == 0
							&& V[i - 8] > 0 && V[i - 13] == 0)
						valor--;
				}
			}
		}

		return valor;
	}

	private static int heuristicaDefensiva(int[] vetorCasas){
		
		int valor = 0;
		int linha = 0;
		for(int i = 0; i<32; i++){
			
			if(vetorCasas[i]>0){
				linha = (int) Math.ceil(i / 4);
				if(linha%2==1 && linha<7 && i%4!=3){
					if(vetorCasas[i-4]==0 && vetorCasas[i+5]<0)
						valor--;
					else if (vetorCasas[i-3]==0 && vetorCasas[i+4]<0)
						valor--;
					else if(vetorCasas[i-3]==-2 && vetorCasas[i+4]==0)
						valor--;
					else if (vetorCasas[i-4]==-2 && vetorCasas[i+5]==0)
						valor--;
					
				}
				else if(linha%2==0 && linha>0 && i%4!=0){
					if(vetorCasas[i-4]==0 && vetorCasas[i+3]<0)
						valor--;
					else if (vetorCasas[i-5]==0 && vetorCasas[i+4]<0)
						valor--;
					else if(vetorCasas[i-4]==-2 && vetorCasas[i+3]==0)
						valor--;
					else if (vetorCasas[i-5]==-2 && vetorCasas[i+4]==0)
						valor--;
				}			
			}		
		}
		return valor;
	}


	// verificar se estï¿œ correto!! se puder, usar uma relaï¿œï¿œo mais simples
	private static int[][] uniToBi(int[] vetorCasas) {
		int[][] tabuleiro = new int[8][8];

		for (int i = 0; i < 32; i++) {
			tabuleiro[i / 4][(i / 4) % 2 == 0 ? (i - (i / 4) * 4) * 2
					: (i - (i / 4) * 4) * 2 + 1] = vetorCasas[i];
			// tabuleiro[i/4][i - 4*(i/4)+]
		}
		return tabuleiro;
	}

	// conferir!!
	// private static int[] biToUni(int[][] tabuleiro) {
	// int[] vetorCasas = new int[32];
	//
	// for (int i = 0; i < 8; i++) {
	// for (int j = 0; j < 8; j++) {
	// if ((i + j) % 2 == 0)
	// vetorCasas[(i) * 4 + j / 2] = tabuleiro[i][j];
	//
	// }
	// }
	//
	// return vetorCasas;
	// }

	private static int heuristicaDamaKiller(int[] vetorCasas) {

		int soma = 0;

		int[][] tabuleiro = uniToBi(vetorCasas);

		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 8; j++) {
				if (tabuleiro[i][j] == 2) {
					// pontuaï¿œï¿œo mï¿œxima (+10) se a dama estiver atrï¿œs de
					// uma peï¿œa normal inimiga

					if ((getValorTabuleiro(tabuleiro, i - 1, j - 1) == -1
							&& getValorTabuleiro(tabuleiro, i - 2, j - 2) == 0
							&& getPoint(j - 1, i - 1) >= 0
							&& getPoint(j - 1, i - 1) < 32
							&& getPoint(j - 2, i - 2) >= 0 && getPoint(j - 2,
							i - 2) < 32)
							|| (getValorTabuleiro(tabuleiro, i - 1, j + 1) == -1
									&& getValorTabuleiro(tabuleiro, i - 2,
											j + 2) == 0
									&& getPoint(j + 1, i - 1) >= 0
									&& getPoint(j + 1, i - 1) < 32
									&& getPoint(j + 2, i - 2) >= 0 && getPoint(
									j + 2, i - 2) < 32))
						soma = soma + 10;
					// pontuaï¿œï¿œo mï¿œdia (+5) se a dama estiver a duas
					// diagonais de distï¿œncia

					else if ((getValorTabuleiro(tabuleiro, i - 2, j - 2) < 0
							&& getPoint(j - 2, i - 2) >= 0 && getPoint(j - 2,
							i - 2) < 32)
							|| (getValorTabuleiro(tabuleiro, i - 2, j + 2) < 0
									&& getPoint(j + 2, i - 2) >= 0 && getPoint(
									j + 2, i - 2) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 2, j - 2) < 0
									&& getPoint(j - 2, i + 2) >= 0 && getPoint(
									j - 2, i + 2) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 2, j + 2) < 0
									&& getPoint(j + 2, i + 2) >= 0 && getPoint(
									j + 2, i + 2) < 32))
						soma = soma + 8;
					// pontuaï¿œï¿œo nula (0) se a dama estiver a trï¿œs
					// diagonais de distï¿œncia

					else if ((getValorTabuleiro(tabuleiro, i - 3, j - 3) < 0
							&& getPoint(j - 3, i - 3) >= 0 && getPoint(j - 3,
							i - 3) < 32)
							|| (getValorTabuleiro(tabuleiro, i - 3, j + 3) < 0
									&& getPoint(j + 3, i - 3) >= 0 && getPoint(
									j + 3, i - 3) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 3, j + 3) < 0
									&& getPoint(j + 3, i + 3) >= 0 && getPoint(
									j + 3, i + 3) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 3, j - 3) < 0
									&& getPoint(j - 3, i + 3) >= 0 && getPoint(
									j - 3, i + 3) < 32))
						soma = soma + 4
						;
					
					else if ((getValorTabuleiro(tabuleiro, i - 4, j - 4) < 0
							&& getPoint(j - 4, i - 4) >= 0 && getPoint(j - 4,
							i - 4) < 32)
							|| (getValorTabuleiro(tabuleiro, i - 4, j + 4) < 0
									&& getPoint(j + 4, i - 4) >= 0 && getPoint(
									j + 4, i - 4) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 4, j + 4) < 0
									&& getPoint(j + 4, i + 4) >= 0 && getPoint(
									j + 4, i + 4) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 4, j - 4) < 0
									&& getPoint(j - 4, i + 4) >= 0 && getPoint(
									j - 4, i + 4) < 32))
						soma = soma + 3
						;
					
					else if ((getValorTabuleiro(tabuleiro, i - 5, j - 5) < 0
							&& getPoint(j - 5, i - 5) >= 0 && getPoint(j - 5,
							i - 5) < 32)
							|| (getValorTabuleiro(tabuleiro, i - 5, j + 5) < 0
									&& getPoint(j + 5, i - 5) >= 0 && getPoint(
									j + 5, i - 5) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 5, j + 5) < 0
									&& getPoint(j + 5, i + 5) >= 0 && getPoint(
									j + 5, i + 5) < 32)
							|| (getValorTabuleiro(tabuleiro, i + 5, j - 5) < 0
									&& getPoint(j - 5, i + 5) >= 0 && getPoint(
									j - 5, i + 5) < 32))
						soma = soma + 2
						;
					// pontuaï¿œï¿œo negativa (-5) para distï¿œncias maiores
					else
						soma = soma;
				}
			}
		}

		return soma;
	}

	private static int getY(int p) {

		return p / 4;
	}

	private static int getX(int p) {
		return (p / 4) % 2 == 0 ? (p - (p / 4) * 4) * 2
				: (p - (p / 4) * 4) * 2 + 1;
	}

	private static int getPoint(int x, int y) {
		int valor = -1;

		valor = (int) y * 4 + x / 2;

		if (valor >= 0 && valor < 32 && (x + y) % 2 == 0)
			return valor;

		else
			return -1;
	}

	private static int getValorTabuleiro(int[][] tab, int x, int y) {

		if ((x < 8 && x >= 0) && (y < 8 && y >= 0))
			return tab[x][y];

		else
			return 10;
	}

	public static int[] getPesos() {
		int[] pesos = new int[NUMERO_HEURISTICAS];
		pesos[0] = getHPosicional();
		pesos[1] = getHAvancoAliado();
		pesos[2] = getHAvancoInimigo();
		pesos[3] = getHMobilidade();
		pesos[4] = getHDamas();
		pesos[5] = getHVala();
		pesos[6] = getHRetaguarda();
		pesos[7] = getHDyke();
		pesos[8] = getHThret();
		pesos[9] = getHMultiCadeia();
		pesos[10] = getHDamaKiller();
		pesos[11] = getHNumeroPecas();
		pesos[12] = getHDefensiva();
		return pesos;
	}

	public static void setPesos(int[] pesos) {

		setHPosicional(pesos[0]);
		setHAvancoAliado(pesos[1]);
		setHAvancoInimigo(pesos[2]);
		setHMobilidade(pesos[3]);
		setHDamas(pesos[4]);
		setHVala(pesos[5]);
		setHRetaguarda(pesos[6]);
		setHDyke(pesos[7]);
		setHThret(pesos[8]);
		setHMultiCadeia(pesos[9]);
		setHDamaKiller(pesos[10]);
		setHNumeroPecas(pesos[11]);
		setHDefensiva(pesos[12]);
	}

	public static int[] getValorHeuristicas(int[] vetorCasas) {

		int[] heuristicas = new int[NUMERO_HEURISTICAS];
		heuristicas[0] = heuristicaPosicional(vetorCasas);
		heuristicas[1] = heuristicaAvancoAliado(vetorCasas);
		heuristicas[2] = heuristicaAvancoInimigo(vetorCasas);
		heuristicas[3] = heuristicaMobilidade(vetorCasas);
		heuristicas[4] = heuristicaDamas(vetorCasas);
		heuristicas[5] = heuristicaVala(vetorCasas);
		heuristicas[6] = heuristicaRetaguarda(vetorCasas);
		heuristicas[7] = heuristicaDyke(vetorCasas);
		heuristicas[8] = heuristicaThret(vetorCasas);
		heuristicas[9] = heuristicaAntiCadeia(vetorCasas);
		heuristicas[10] = heuristicaDamaKiller(vetorCasas);
		heuristicas[11] = heuristicaNumeroPecas(vetorCasas);
		heuristicas[12] = heuristicaDefensiva(vetorCasas);

		return heuristicas;
	}

	public static int getHPosicional() {
		return hPosicional;
	}

	public static void setHPosicional(int posicional) {
		hPosicional = posicional;
	}

	public static int getHAvancoAliado() {
		return hAvancoAliado;
	}

	public static void setHAvancoAliado(int avancoAliado) {
		hAvancoAliado = avancoAliado;
	}

	public static int getHAvancoInimigo() {
		return hAvancoInimigo;
	}

	public static void setHAvancoInimigo(int avancoInimigo) {
		hAvancoInimigo = avancoInimigo;
	}

	public static int getHMobilidade() {
		return hMobilidade;
	}

	public static void setHMobilidade(int mobilidade) {
		hMobilidade = mobilidade;
	}

	public static int getHDamas() {
		return hDamas;
	}

	public static void setHDamas(int damas) {
		hDamas = damas;
	}

	public static int getHVala() {
		return hVala;
	}

	public static void setHVala(int vala) {
		hVala = vala;
	}

	public static int getHRetaguarda() {
		return hRetaguarda;
	}

	public static void setHRetaguarda(int retaguarda) {
		hRetaguarda = retaguarda;
	}

	public static int getHDyke() {
		return hDyke;
	}

	public static void setHDyke(int dyke) {
		hDyke = dyke;
	}

	public static int getHThret() {
		return hThret;
	}

	public static void setHThret(int thret) {
		hThret = thret;
	}

	public static int getHMultiCadeia() {
		return hMultiCadeia;
	}

	public static void setHMultiCadeia(int multiCadeia) {
		hMultiCadeia = multiCadeia;
	}

	public static int getHDamaKiller() {
		return hDamaKiller;
	}

	public static void setHDamaKiller(int damaKiller) {
		hDamaKiller = damaKiller;
	}

	public static int getHNumeroPecas() {
		return hNumeroPecas;
	}

	public static void setHNumeroPecas(int numeroPecas) {
		hNumeroPecas = numeroPecas;
	}

	public static int getHDefensiva() {
		return hDefensiva;
	}

	public static void setHDefensiva(int defensiva) {
		hDefensiva = defensiva;
	}

}
